/******************************************************************************
 cnome: A C++ source "genes" discover. :-)

 See more details at:

   http://www.codeplex.com/cnome

 The original author site is at: http://www.alexandre-barbosa.com/

 Copyright (c) 2008 Alexandre Barbosa.
 Distributed under the MIT License. (See accompanying file LICENSE-MIT.txt 
 or at http://www.codeplex.com/cnome/license)
 ******************************************************************************/

#ifndef EXPRESSIONS_DEFINITION_H
#define EXPRESSIONS_DEFINITION_H

#include <boost/spirit/include/classic_dynamic.hpp>

#include "actions.h"
#include "cnome.h"
#include "directives.h"
#include "tokens.h"
#include "util.h"

namespace cnome {
template <typename ScannerT> 
void
cpp::definition<ScannerT>::expressions(cpp const& self)
    {
        using namespace actions;
        using namespace directive;
        using namespace util;

        primary_expression =
                literal                                   
            |	_THIS                                      
            |	( LEFTPAREN >> expression >> RIGHTPAREN )
            |	remain_scope_d[ sss_d[ id_expression ] ]
        ;

        id_expression =
                unqualified_id 
            |	qualified_id
        ;

        unqualified_id =
                if_p(lookahead_d[IDENTIFIER>>COLON_COLON])[NOTHING].
                else_p[IDENTIFIER]                            
            |	operator_function_id                                    
            |	conversion_function_id                                  
            |	( COMPL >> class_name )                                 
            |	template_id
        ;

        unqualified_id_raw =
                if_p(lookahead_d[IDENTIFIER_HELPER>>COLON_COLON])[NOTHING].
                else_p[IDENTIFIER_HELPER]                            
            |	operator_function_id                                    
            |	conversion_function_id                                  
            |	( COMPL >> class_name )                                 
            |	template_id
        ;


        qualified_id =
                (      !COLON_COLON[&scopeIsAbsolut][&enter_scope] >> nested_name_specifier 
                    >> !TEMPLATE >> unqualified_id    )
            |	(      COLON_COLON[&scopeIsAbsolut][&enter_scope] 
                    >> ( IDENTIFIER | operator_function_id | template_id )    )
        ;

        nested_name_specifier =
                 ( class_or_namespace_name[&enter_scope] 
                     >> if_p(sss_d[nested_name_specifier_a])[EPSILON].else_p[EPSILON[&leaveScope] >> NOTHING] )
            |    ( class_or_namespace_name[&enter_scope] 
                     >> if_p(sss_d[nested_name_specifier_b])[EPSILON].else_p[EPSILON[&leaveScope] >> NOTHING] )
        ;

        nested_name_specifier_a =
            ( COLON_COLON  >> !nested_name_specifier ) 
        ;

        nested_name_specifier_b =
            ( COLON_COLON  >> TEMPLATE >> nested_name_specifier ) 
        ;

        class_or_namespace_name =
               if_p(EPSILON[&enableHandleTypeDef] >> class_name)[EPSILON[&disableHandleTypeDef]]. 
                else_p[EPSILON[&disableHandleTypeDef] >> NOTHING]
            |	namespace_name 
        ;

        postfix_expression =
            post_fix_expression_a >> post_fix_expression_helper
        ;

        post_fix_expression_helper =
                ( post_fix_expression_b >> post_fix_expression_helper ) 
            |	EPSILON
        ;

        post_fix_expression_a =
                primary_expression 
            |	( simple_type_specifier >> LEFTPAREN >> !expression_list >> RIGHTPAREN ) 
            |	(		TYPENAME 
                    >> sss_d[ !(COLON_COLON[&scopeIsAbsolut][&enter_scope]) >> nested_name_specifier 
                           >> IDENTIFIER ] >> LEFTPAREN >> expression_list >> RIGHTPAREN		      ) 
            |	(		TYPENAME 
                    >> sss_d[ !(COLON_COLON[&scopeIsAbsolut][&enter_scope]) >> nested_name_specifier 
                           >> !TEMPLATE >> template_id ] >> LEFTPAREN >> !expression_list >> RIGHTPAREN ) 
            |   (		DYNAMIC_CAST >> LESS >> sss_d[ type_id ] >> GREATER >> LEFTPAREN 
                    >>	expression >> RIGHTPAREN                                 ) 
            |   (		STATIC_CAST >> LESS >> sss_d[ type_id ] >> GREATER >> LEFTPAREN 
                    >>	expression >> RIGHTPAREN                                 ) 
            |   (		REINTERPRET_CAST >> LESS >> sss_d[ type_id ] >> GREATER >> LEFTPAREN 
                    >>	expression >> RIGHTPAREN                                    ) 
            |	(		CONST_CAST >> LESS >> sss_d[ type_id ] >> GREATER >> LEFTPAREN 
                    >>	expression >> RIGHTPAREN                              ) 
            |   ( TYPEID >> LEFTPAREN >> expression >> RIGHTPAREN ) 
            |   ( TYPEID >> LEFTPAREN >> sss_d[ type_id ] >> RIGHTPAREN ) 
        ;

        post_fix_expression_b = 
                ( LEFTBRACKET >> expression >> RIGHTBRACKET           ) 
            |	( LEFTPAREN >> !expression_list >> RIGHTPAREN         ) 
            |	( DOT >> !TEMPLATE >> sss_d[ !COLON_COLON >> id_expression ]  ) 
            |	( ARROW >> !TEMPLATE >> sss_d[ !COLON_COLON >> id_expression ] ) 
            |	( DOT >> pseudo_destructor_name                       ) 
            |	( ARROW >> pseudo_destructor_name                     ) 
            |	PLUSPLUS                                                
            |	MINUSMINUS
        ;

        expression_list =
            assignment_expression >> expression_list_helper
        ;

        pseudo_destructor_name =
                last_remain_scope_d[
                    (	sss_d[ !COLON_COLON >> !nested_name_specifier >> type_name 
                            >> COLON_COLON >> COMPL >> type_name ] ) ]
            |	last_remain_scope_d[
                    (	sss_d[ !COLON_COLON >> nested_name_specifier >> TEMPLATE 
                            >> COLON_COLON >> COMPL >> type_name ] ) ]
            |	last_remain_scope_d[
                    (	sss_d[ !COLON_COLON >> !nested_name_specifier >> COMPL 
                           >> type_name ] ) ]
        ;

        unary_expression =
                postfix_expression                               
            |	( PLUSPLUS >> cast_expression )                  
            |	( MINUSMINUS >> cast_expression )                
            |	( unary_operator >> cast_expression )            
            |	( SIZEOF >> unary_expression )                   
            |	( SIZEOF >> LEFTPAREN >> sss_d[ type_id ] >> RIGHTPAREN ) 
            |	new_expression                                   
            |	delete_expression
        ;

        unary_operator =
                STAR
            |	AND  
            |	PLUS
            |	MINUS    
            |	NOT      
            |	COMPL
        ;

        new_expression =
                ( !COLON_COLON >> NEW >> !new_placement >> new_type_id >> !new_initializer     ) 
            |	(		!COLON_COLON >> NEW >> !new_placement >> LEFTPAREN >> sss_d[ type_id ] 
                    >>  RIGHTPAREN >> !new_initializer                                         ) 
        ;

        new_placement =
            LEFTPAREN >> expression_list >> RIGHTPAREN
        ;

        new_type_id =
            type_specifier_seq >> !new_declarator
        ;

        new_declarator =
                ( ptr_operator >> !new_declarator ) 
            |	direct_new_declarator
        ;

        direct_new_declarator =
            ( LEFTBRACKET >> expression >> RIGHTBRACKET ) >> direct_new_declarator_helper
        ;

        direct_new_declarator_helper =
                ( LEFTBRACKET >> constant_expression >> RIGHTBRACKET >> direct_new_declarator_helper ) 
            |	EPSILON
        ;

        new_initializer =
            LEFTPAREN >> !expression_list >> RIGHTPAREN
        ;

        delete_expression =
                ( !COLON_COLON >> DELETE_ >> cast_expression ) 
            |	( !COLON_COLON >> DELETE_ >> LEFTBRACKET >> RIGHTBRACKET >> cast_expression )
        ;

        expression_list_helper =
                ( COMMA >> assignment_expression >> expression_list_helper ) 
            |	EPSILON
        ;

        cast_expression =
                ( LEFTPAREN >> sss_d[ type_id ] >> RIGHTPAREN >> cast_expression )
            |	unary_expression 
        ;

        pm_expression =
            cast_expression >> pm_expression_helper
        ;

        pm_expression_helper =
                ( DOTSTAR >> cast_expression >> pm_expression_helper   ) 
            |	( ARROWSTAR >> cast_expression >> pm_expression_helper ) 
            |	EPSILON
        ;

        multiplicative_expression =
            pm_expression >> multiplicative_expression_helper
        ;

        multiplicative_expression_helper =
                ( STAR >> pm_expression >> multiplicative_expression_helper    ) 
            |	( DIVIDE >> pm_expression >> multiplicative_expression_helper  ) 
            |	( PERCENT >> pm_expression >> multiplicative_expression_helper ) 
            |	EPSILON
        ;

        additive_expression =
            multiplicative_expression >> additive_expression_helper
        ;

        additive_expression_helper =
                ( PLUS >> multiplicative_expression >> additive_expression_helper  ) 
            |	( MINUS >> multiplicative_expression >> additive_expression_helper ) 
            |	EPSILON
        ;

        shift_expression =
            additive_expression >> shift_expression_helper
        ;

        shift_expression_helper =
                ( SHIFTLEFT >> additive_expression >> shift_expression_helper  ) 
            |	( SHIFTRIGHT >> additive_expression >> shift_expression_helper ) 
            |	EPSILON 
        ;

        relational_expression =
                shift_expression[&isLOpLastSmbGrt]
            >>  if_p(lookahead_d[LASTSMBFLOPISGREATER >> GREATER])[NOTHING].else_p[EPSILON]
            >>	relational_expression_helper
        ;

        relational_expression_helper =
                ( LESS >> shift_expression >> relational_expression_helper         ) 
            |	( GREATER >> shift_expression >> relational_expression_helper      ) 
            |	( LESSEQUAL >> shift_expression >> relational_expression_helper    ) 
            |	( GREATEREQUAL >> shift_expression >> relational_expression_helper ) 
            |	EPSILON 
        ;

        equality_expression =
            relational_expression >> equality_expression_helper
        ;

        equality_expression_helper =
                ( EQUAL >> relational_expression >> equality_expression_helper    ) 
            |	( NOTEQUAL >> relational_expression >> equality_expression_helper ) 
            |	EPSILON
        ;

        and_expression =
            equality_expression >> and_expression_helper
        ;

        and_expression_helper =
                ( AND >> equality_expression >> and_expression_helper ) 
            |	EPSILON
        ;

        exclusive_or_expression =
            and_expression >> exclusive_or_expression_helper
        ;

        exclusive_or_expression_helper =
                ( XOR >> and_expression >> exclusive_or_expression_helper ) 
            |	EPSILON
        ;

        inclusive_or_expression =
            exclusive_or_expression >> inclusive_or_expression_helper
        ;

        inclusive_or_expression_helper =
                ( OR >> exclusive_or_expression >> inclusive_or_expression_helper ) 
            |	EPSILON
        ;

        logical_and_expression = 
            inclusive_or_expression >> logical_and_expression_helper
        ;

        logical_and_expression_helper =
                ( ANDAND >> inclusive_or_expression >> logical_and_expression_helper ) 
            |	EPSILON
        ;

        logical_or_expression =
            logical_and_expression >> logical_or_expression_helper
        ;

        logical_or_expression_helper =
                ( OROR >> logical_and_expression >> logical_or_expression_helper ) 
            |	EPSILON
        ;

        conditional_expression =
                logical_or_expression  
            >>	if_p(lookahead_d[QUESTION_MARK])
                    [QUESTION_MARK >> expression >> COLON >> assignment_expression]
        ;

        assignment_expression =
                if_p(	lookahead_d[	
                            remain_scope_d[
                                    conditional_expression 
                                    >> assignment_operator ]] )
                [NOTHING].else_p[conditional_expression]
            |	(	logical_or_expression >> assignment_operator 
                    >> assignment_expression )             
            |	throw_expression
        ;

        assignment_operator =
                ASSIGN 
            |	STARASSIGN 
            |	DIVIDEASSIGN 
            |	PERCENTASSIGN 
            |	PLUSASSIGN 
            |	MINUSASSIGN 
            |	SHIFTRIGHTASSIGN 
            |	SHIFTLEFTASSIGN 
            |	ANDASSIGN 
            |	XORASSIGN 
            |	ORASSIGN
        ;

        expression =
            assignment_expression >> expression_helper
        ;

        expression_helper =
                ( COMMA >> assignment_expression >> expression_helper ) 
            |	EPSILON
        ;

        constant_expression =
            conditional_expression
        ;

        literal =
                INTLIT    
            |	CHARLIT   
            |	FLOATLIT  
            |	STRINGLIT 
            |	BOOLLIT
        ;
        //  End grammar definition
          
        // turn on the debugging info.
        BOOST_SPIRIT_DEBUG_RULE(primary_expression);
        BOOST_SPIRIT_DEBUG_RULE(expression);
        BOOST_SPIRIT_DEBUG_RULE(literal);
        BOOST_SPIRIT_DEBUG_RULE(id_expression);
        BOOST_SPIRIT_DEBUG_RULE(postfix_expression);
        BOOST_SPIRIT_DEBUG_RULE(post_fix_expression_a);
        BOOST_SPIRIT_DEBUG_RULE(post_fix_expression_helper);
        BOOST_SPIRIT_DEBUG_RULE(post_fix_expression_b);
        BOOST_SPIRIT_DEBUG_RULE(simple_type_specifier);
        BOOST_SPIRIT_DEBUG_RULE(expression_list);
        BOOST_SPIRIT_DEBUG_RULE(nested_name_specifier);
        BOOST_SPIRIT_DEBUG_RULE(template_id);
        BOOST_SPIRIT_DEBUG_RULE(type_id);
        BOOST_SPIRIT_DEBUG_RULE(id_expression);
        BOOST_SPIRIT_DEBUG_RULE(pseudo_destructor_name);
        BOOST_SPIRIT_DEBUG_RULE(type_name);
        BOOST_SPIRIT_DEBUG_RULE(cast_expression);
        BOOST_SPIRIT_DEBUG_RULE(type_specifier_seq);
        BOOST_SPIRIT_DEBUG_RULE(new_declarator);
        BOOST_SPIRIT_DEBUG_RULE(ptr_operator);
        BOOST_SPIRIT_DEBUG_RULE(direct_new_declarator);
        BOOST_SPIRIT_DEBUG_RULE(direct_new_declarator_helper);
        BOOST_SPIRIT_DEBUG_RULE(constant_expression);
        BOOST_SPIRIT_DEBUG_RULE(cast_expression);
        BOOST_SPIRIT_DEBUG_RULE(unary_expression);
        BOOST_SPIRIT_DEBUG_RULE(type_id);
        BOOST_SPIRIT_DEBUG_RULE(unary_operator);
        BOOST_SPIRIT_DEBUG_RULE(new_expression);
        BOOST_SPIRIT_DEBUG_RULE(delete_expression);
        BOOST_SPIRIT_DEBUG_RULE(new_placement);
        BOOST_SPIRIT_DEBUG_RULE(new_type_id);
        BOOST_SPIRIT_DEBUG_RULE(new_initializer);
        BOOST_SPIRIT_DEBUG_RULE(delete_expression);
        BOOST_SPIRIT_DEBUG_RULE(expression_list);
        BOOST_SPIRIT_DEBUG_RULE(assignment_expression);
        BOOST_SPIRIT_DEBUG_RULE(expression_list_helper);
        BOOST_SPIRIT_DEBUG_RULE(nested_name_specifier);
        BOOST_SPIRIT_DEBUG_RULE(class_or_namespace_name);
        BOOST_SPIRIT_DEBUG_RULE(class_name);
        BOOST_SPIRIT_DEBUG_RULE(namespace_name);
        BOOST_SPIRIT_DEBUG_RULE(id_expression);
        BOOST_SPIRIT_DEBUG_RULE(unqualified_id);
        BOOST_SPIRIT_DEBUG_RULE(qualified_id);
        BOOST_SPIRIT_DEBUG_RULE(operator_function_id);
        BOOST_SPIRIT_DEBUG_RULE(conversion_function_id);
        BOOST_SPIRIT_DEBUG_RULE(nested_name_specifier);
        BOOST_SPIRIT_DEBUG_RULE(template_id);
        BOOST_SPIRIT_DEBUG_RULE(unqualified_id);
        BOOST_SPIRIT_DEBUG_RULE(operator_function_id);
        BOOST_SPIRIT_DEBUG_RULE(conversion_function_id);
        BOOST_SPIRIT_DEBUG_RULE(nested_name_specifier);
        BOOST_SPIRIT_DEBUG_RULE(class_name);
        BOOST_SPIRIT_DEBUG_RULE(template_id);
        BOOST_SPIRIT_DEBUG_RULE(logical_or_expression);
        BOOST_SPIRIT_DEBUG_RULE(condition_expression);
        BOOST_SPIRIT_DEBUG_RULE(expression);
        BOOST_SPIRIT_DEBUG_RULE(assignment_expression);
        BOOST_SPIRIT_DEBUG_RULE(constant_expression);
        BOOST_SPIRIT_DEBUG_RULE(conditional_expression);
        BOOST_SPIRIT_DEBUG_RULE(expression);
        BOOST_SPIRIT_DEBUG_RULE(expression_helper);
        BOOST_SPIRIT_DEBUG_RULE(logical_or_expression);
        BOOST_SPIRIT_DEBUG_RULE(condition_expression);
        BOOST_SPIRIT_DEBUG_RULE(assignment_operator);
        BOOST_SPIRIT_DEBUG_RULE(throw_expression);
        BOOST_SPIRIT_DEBUG_RULE(logical_or_expression);
        BOOST_SPIRIT_DEBUG_RULE(logical_or_expression_helper);
        BOOST_SPIRIT_DEBUG_RULE(logical_and_expression);
        BOOST_SPIRIT_DEBUG_RULE(inclusive_or_expression);
        BOOST_SPIRIT_DEBUG_RULE(logical_and_expression_helper);
        BOOST_SPIRIT_DEBUG_RULE(exclusive_or_expression);
        BOOST_SPIRIT_DEBUG_RULE(inclusive_or_expression_helper);
        BOOST_SPIRIT_DEBUG_RULE(and_expression);
        BOOST_SPIRIT_DEBUG_RULE(exclusive_or_expression_helper);
        BOOST_SPIRIT_DEBUG_RULE(equality_expression);
        BOOST_SPIRIT_DEBUG_RULE(and_expression_helper);
        BOOST_SPIRIT_DEBUG_RULE(relational_expression);
        BOOST_SPIRIT_DEBUG_RULE(equality_expression_helper);
        BOOST_SPIRIT_DEBUG_RULE(shift_expression);
        BOOST_SPIRIT_DEBUG_RULE(relational_expression_helper);
        BOOST_SPIRIT_DEBUG_RULE(additive_expression);
        BOOST_SPIRIT_DEBUG_RULE(shift_expression_helper);
        BOOST_SPIRIT_DEBUG_RULE(multiplicative_expression);
        BOOST_SPIRIT_DEBUG_RULE(additive_expression_helper);
        BOOST_SPIRIT_DEBUG_RULE(pm_expression);
        BOOST_SPIRIT_DEBUG_RULE(pm_expression_helper);
        BOOST_SPIRIT_DEBUG_RULE(multiplicative_expression_helper);
        BOOST_SPIRIT_DEBUG_RULE(literal);
        BOOST_SPIRIT_DEBUG_RULE(nested_name_specifier_a);
        BOOST_SPIRIT_DEBUG_RULE(nested_name_specifier_b);
        // Begin: FIX Bug 16 - Nested template declaration isn't parsed
        // ALB - 08jun06
        BOOST_SPIRIT_DEBUG_RULE(LASTSMBFLOPISGREATER);
        // End: FIX Bug 16

        BOOST_SPIRIT_DEBUG_RULE(_THIS);
        BOOST_SPIRIT_DEBUG_RULE(LEFTPAREN);
        BOOST_SPIRIT_DEBUG_RULE(RIGHTPAREN);
        BOOST_SPIRIT_DEBUG_RULE(TYPENAME);
        BOOST_SPIRIT_DEBUG_RULE(COLON_COLON);
        BOOST_SPIRIT_DEBUG_RULE(IDENTIFIER);
        BOOST_SPIRIT_DEBUG_RULE(TEMPLATE);
        BOOST_SPIRIT_DEBUG_RULE(DYNAMIC_CAST);
        BOOST_SPIRIT_DEBUG_RULE(LESS);
        BOOST_SPIRIT_DEBUG_RULE(GREATER);
        BOOST_SPIRIT_DEBUG_RULE(STATIC_CAST);
        BOOST_SPIRIT_DEBUG_RULE(REINTERPRET_CAST);
        BOOST_SPIRIT_DEBUG_RULE(CONST_CAST);
        BOOST_SPIRIT_DEBUG_RULE(TYPEID);
        BOOST_SPIRIT_DEBUG_RULE(LEFTBRACKET);
        BOOST_SPIRIT_DEBUG_RULE(RIGHTBRACKET);
        BOOST_SPIRIT_DEBUG_RULE(COMPL);
        BOOST_SPIRIT_DEBUG_RULE(DOT);
        BOOST_SPIRIT_DEBUG_RULE(ARROW);
        BOOST_SPIRIT_DEBUG_RULE(NEW);
        BOOST_SPIRIT_DEBUG_RULE(DELETE_);
        BOOST_SPIRIT_DEBUG_RULE(EPSILON);
        BOOST_SPIRIT_DEBUG_RULE(LEFTPAREN);
        BOOST_SPIRIT_DEBUG_RULE(RIGHTPAREN);
        BOOST_SPIRIT_DEBUG_RULE(SIZEOF);
        BOOST_SPIRIT_DEBUG_RULE(PLUSPLUS);
        BOOST_SPIRIT_DEBUG_RULE(MINUSMINUS);
        BOOST_SPIRIT_DEBUG_RULE(STAR);
        BOOST_SPIRIT_DEBUG_RULE(AND);
        BOOST_SPIRIT_DEBUG_RULE(PLUS);
        BOOST_SPIRIT_DEBUG_RULE(MINUS);
        BOOST_SPIRIT_DEBUG_RULE(COMPL);
        BOOST_SPIRIT_DEBUG_RULE(COMMA);
        BOOST_SPIRIT_DEBUG_RULE(EPSILON);
        BOOST_SPIRIT_DEBUG_RULE(COLON_COLON);
        BOOST_SPIRIT_DEBUG_RULE(TEMPLATE);
        BOOST_SPIRIT_DEBUG_RULE(COLON_COLON);
        BOOST_SPIRIT_DEBUG_RULE(IDENTIFIER);
        BOOST_SPIRIT_DEBUG_RULE(TEMPLATE);
        BOOST_SPIRIT_DEBUG_RULE(IDENTIFIER);
        BOOST_SPIRIT_DEBUG_RULE(COMPL);
        BOOST_SPIRIT_DEBUG_RULE(QUESTION_MARK);
        BOOST_SPIRIT_DEBUG_RULE(COLON);
        BOOST_SPIRIT_DEBUG_RULE(ASSIGN);
        BOOST_SPIRIT_DEBUG_RULE(STARASSIGN);
        BOOST_SPIRIT_DEBUG_RULE(DIVIDEASSIGN);
        BOOST_SPIRIT_DEBUG_RULE(PERCENTASSIGN);
        BOOST_SPIRIT_DEBUG_RULE(PLUSASSIGN);
        BOOST_SPIRIT_DEBUG_RULE(MINUSASSIGN);
        BOOST_SPIRIT_DEBUG_RULE(SHIFTRIGHTASSIGN);
        BOOST_SPIRIT_DEBUG_RULE(SHIFTLEFTASSIGN);
        BOOST_SPIRIT_DEBUG_RULE(ANDASSIGN);
        BOOST_SPIRIT_DEBUG_RULE(XORASSIGN);
        BOOST_SPIRIT_DEBUG_RULE(ORASSIGN);
        BOOST_SPIRIT_DEBUG_RULE(OROR);
        BOOST_SPIRIT_DEBUG_RULE(ANDAND);
        BOOST_SPIRIT_DEBUG_RULE(OR);
        BOOST_SPIRIT_DEBUG_RULE(XOR);
        BOOST_SPIRIT_DEBUG_RULE(AND);
        BOOST_SPIRIT_DEBUG_RULE(EQUAL);
        BOOST_SPIRIT_DEBUG_RULE(NOTEQUAL);
        BOOST_SPIRIT_DEBUG_RULE(LESS);
        BOOST_SPIRIT_DEBUG_RULE(GREATER);
        BOOST_SPIRIT_DEBUG_RULE(LESSEQUAL);
        BOOST_SPIRIT_DEBUG_RULE(GREATEREQUAL);
        BOOST_SPIRIT_DEBUG_RULE(SHIFTLEFT);
        BOOST_SPIRIT_DEBUG_RULE(SHIFTRIGHT);
        BOOST_SPIRIT_DEBUG_RULE(PLUS);
        BOOST_SPIRIT_DEBUG_RULE(MINUS);
        BOOST_SPIRIT_DEBUG_RULE(STAR);
        BOOST_SPIRIT_DEBUG_RULE(DIVIDE);
        BOOST_SPIRIT_DEBUG_RULE(PERCENT);
        BOOST_SPIRIT_DEBUG_RULE(DOTSTAR);
        BOOST_SPIRIT_DEBUG_RULE(ARROWSTAR);
        BOOST_SPIRIT_DEBUG_RULE(EPSILON);
        BOOST_SPIRIT_DEBUG_RULE(INTLIT);
        BOOST_SPIRIT_DEBUG_RULE(CHARLIT);
        BOOST_SPIRIT_DEBUG_RULE(FLOATLIT);
        BOOST_SPIRIT_DEBUG_RULE(STRINGLIT);
        BOOST_SPIRIT_DEBUG_RULE(BOOLLIT);
        BOOST_SPIRIT_DEBUG_RULE(TRUE_);
        BOOST_SPIRIT_DEBUG_RULE(FALSE_);
        BOOST_SPIRIT_DEBUG_RULE(EPSILON);
        BOOST_SPIRIT_DEBUG_RULE(NOTHING);
    }
}  // namespace cnome
#endif // EXPRESSIONS_DEFINITION_H
